﻿#include "clothingmac.h"

ClothingMac::ClothingMac()
{
    //添加各种参数到列表中
    initRootParasList();
    initRootHMIConfigurationList(m_allParasList);//超级用户界面配置
    initPatternsParasList();
    initSoftwareParasList(m_allParasList);
    initTimeParasList(m_allParasList);
    initMcParasList();
    initWkParasList();

    //初始化控制动作列表
    initOutCtrlList();

    //初始化快捷功能列表
    initShortCutList();

    //初始化辅助功能列表
    initAssistList();

    //初始化花样设置功能列表
    initPatternSetList();

    //参数分类功能
    initParaSetList();

    //初始化传感器列表
    initSensorList();

    //初始化错误代码和状态列表
    initErrorCodeAndStateList();

    //初始化九宫格
    initNinebtn1234();

    //加载右上角信息
    initFileInfoLabel();
}

ClothingMac::~ClothingMac()
{

}

void ClothingMac::initNinebtn1234()
{
    m_nineBtn.insert(1,NineItem(FUN_HEAD_LIFTING,"buttonHeadLifting"));
    m_nineBtn.insert(2,NineItem(FUN_MANUAL_THREAD_CUTTING,"buttonMunualThreadCutting"));
    m_nineBtn.insert(3,NineItem(FUN_PROCESSRESET,"buttonProcessReset"));
    m_nineBtn.insert(4,NineItem(FUN_SIMULATED_STATUS,"buttonSimulatedStatus"));
}

void ClothingMac::initPatternsParasList()
{
    QTextCodec *cod = QTextCodec::codecForLocale();

    //花样参数-花样设置参数-定位点x；范围-1000000--1000000，单位0.01mm，默认 0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_PATTERN,
                                        PATTERNPARA_SORT_DSTR,
                                        SET_ANCHORX, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("AnchorX"),//定位点X
                                        0, -1000000, 1000000, 0, 2, tr("mm"), tr(""),//mm
                                        tr(""), 0, 0,0x0001, operate));

    //花样参数-花样设置参数-定位点y；范围-1000000--1000000，单位0.01mm，默认 0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_PATTERN,
                                        PATTERNPARA_SORT_DSTR ,
                                        SET_ANCHORY, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("AnchorY"),//定位点Y
                                        0, -1000000, 1000000, 0, 2, tr("mm"), tr(""),//mm
                                        tr(""), 0, 0,0x0002, operate));

    //花样参数-花样设置参数-起始点x；范围-1000000--1000000，单位0.01mm，默认 0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_PATTERN,
                                        PATTERNPARA_SORT_DSTR ,
                                        SET_STARTX, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("startX"),//起始点X
                                        0, -1000000, 1000000, 0, 2, tr("mm"), tr(""),//mm
                                        tr(""), 0, 0,0x0003, operate));

    //花样参数-花样设置参数-起始点y；范围-1000000--1000000，单位0.01mm，默认 0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_PATTERN,
                                        PATTERNPARA_SORT_DSTR ,
                                        SET_STARTY, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("startrY"),//起始点Y
                                        0, -1000000, 1000000, 0, 2, tr("mm"), tr(""),//mm
                                        tr(""), 0, 0,0x0004, operate));

    //花样参数-花样设置参数-翻转式样；单位：无 ，范围0-7，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_PATTERN,
                                        PATTERNPARA_SORT_DSTR,
                                        SET_ROTATESTYLE, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Flip style"),//翻转式样
                                        0, 0, 7, 0, 0, tr(""), tr(""),
                                        tr("normalP:0;nRight90P:1;nRight180P:2;nRight270P:3;mirrorP:4;mRight90P:5;mRight180P:6;mRight270P:7"),
                                        0, 0, 0x0005, operate));

    //花样参数-花样设置参数-旋转角度；单位：° ，范围0-90，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_PATTERN,
                                        PATTERNPARA_SORT_DSTR,
                                        SET_ROTATEANGLE, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Rotation angle"),//旋转角度
                                        0, 0, 90, 0, 0, cod->toUnicode("°"), tr(""),//度
                                        tr(""), 0, 0,0x0006, operate));

    //花样参数---------------------------
}

void ClothingMac::initMcParasList()
{
    QTextCodec *cod = QTextCodec::codecForLocale();

    //模版识别装置, 范围0-3，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SETTING,
                                        29, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Template recognition device"),//模版识别装置
                                        0, 0, 3, 0, 0, tr(""), tr(""),
                                        //无装置: 0;条形码:1;编码孔:2;多文件选择:3
                                        tr("No device:0;Bar code:1;Coding hole:2;Multiple files:3"),
                                        0, 0, 0x0001, root));

    //X框传感器坐标, 范围：最小-最大，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_POSITION,
                                        50, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("X frame sensor coordinates"),//X框传感器坐标
                                        0, S32_MIN, S32_MAX, 0, 2, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //Y框传感器坐标, 范围：最小-最大，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_POSITION,
                                        51, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Y frame sensor coordinates"),//Y框传感器坐标
                                        0, S32_MIN, S32_MAX, 0, 2, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //主轴停车传感器角度, 范围：最小-最大，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_POSITION,
                                        52, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle parking sensor angle"),//主轴停车传感器角度
                                        0, S32_MIN, S32_MAX, 0, 2, cod->toUnicode("°"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //升降传感器坐标, 范围：最小-最大，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_POSITION,
                                        53, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Lift sensor coordinates"),//升降传感器坐标
                                        0, S32_MIN, S32_MAX, 0, 2, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //主轴勾线传感器角度, 范围：最小-最大，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_POSITION,
                                        56, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Angle of spindle hook sensor"),//主轴勾线传感器角度
                                        0, S32_MIN, S32_MAX, 0, 2, cod->toUnicode("°"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //主轴点动停车角度, 范围：-36000-36000，默认8500
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_POSITION,
                                        62, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle jog parking angle"),//主轴点动停车角度
                                        8500, -36000, 36000, 8500, 2, cod->toUnicode("°"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //X可移动区域负边界, 范围：最小-最大，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_POSITION,
                                        70, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("X movable area negative boundary"),//X可移动区域负边界
                                        0, S32_MIN, S32_MAX, 0, 2, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //X可移动区域正边界, 范围：最小-最大，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_POSITION,
                                        71, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("X movable area positive boundary"),//X可移动区域正边界
                                        0, S32_MIN, S32_MAX, 0, 2, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //Y可移动区域负边界, 范围：最小-最大，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_POSITION,
                                        72, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Y movable area negative boundary"),//Y可移动区域负边界
                                        0, S32_MIN, S32_MAX, 0, 2, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //Y可移动区域正边界, 范围：最小-最大，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_POSITION,
                                        73, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Y movable area positive boundary"),//Y可移动区域正边界
                                        0, S32_MIN, S32_MAX, 0, 2, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //X可缝纫区域负边界, 范围：最小-最大，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_POSITION,
                                        84, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("X Sewing area negative boundary"),//X可缝纫区域负边界
                                        0, S32_MIN, S32_MAX, 0, 2, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //X可缝纫区域正边界, 范围：最小-最大，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_POSITION,
                                        85, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("X Sewing area positive boundary"),//X可缝纫区域正边界
                                        0, S32_MIN, S32_MAX, 0, 2, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //Y可缝纫区域负边界, 范围：最小-最大，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_POSITION,
                                        86, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Y Sewing area negative boundary"),//Y可缝纫区域负边界
                                        0, S32_MIN, S32_MAX, 0, 2, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //Y可缝纫区域正边界, 范围：最小-最大，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_POSITION,
                                        87, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Y Sewing area positive boundary"),//Y可缝纫区域正边界
                                        0, S32_MIN, S32_MAX, 0, 2, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //xy启动停止速度, 范围1-100，默认10
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        100, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("XY start stop speed"),//xy启动停止速度
                                        10, 1, 100, 10, 0, tr("mm/s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //xy归零运行速度, 范围1-500，默认100
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        101, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("XY zero running speed"),//xy归零运行速度
                                        100, 1, 500, 100, 0, tr("mm/s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //xy空走运行速度, 范围1-1700，默认300
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        102, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("XY simulate running speed"),//xy空走运行速度
                                        300, 1, 1700, 300, 0, tr("mm/s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //xy行走加速度, 范围1-10000，默认1000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        103, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("XY movement acceleration"),//xy行走加速度
                                        1000, 1, 10000, 1000, 0, tr("mm/s2"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //xy刹车加速度, 范围1-10000，默认10000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        104, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("XY brake acceleration"),//xy刹车加速度
                                        10000, 1, 10000, 10000, 0, tr("mm/s2"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //xy手动移动速度1, 范围1-1000，默认10
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        105, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("XY manual movement speed 1"),//xy手动移动速度1
                                        10, 1, 1000, 10, 0, tr("mm/s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //xy手动移动速度2, 范围1-1000，默认100
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        106, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("XY manual movement speed 2"),//xy手动移动速度2
                                        100, 1, 1000, 100, 0, tr("mm/s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //xy手动移动速度3, 范围1-1000，默认300
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        107, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("XY manual movement speed 3"),//xy手动移动速度3
                                        300, 1, 1000, 300, 0, tr("mm/s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //xy最高移动速度, 范围1-1700，默认300
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        108, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("XY maximum moving speed"),//xy最高移动速度
                                        300, 1, 1700, 300, 0, tr("mm/s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //主轴启动停止转速, 范围1-1000，默认100
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        109, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle start stop speed"),//主轴启动停止转速
                                        100, 1, 1000, 100, 0, tr("r/min"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //主轴归零转速, 范围1-3000，默认120
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        110, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle zero reset speed"),//主轴归零转速
                                        120, 1, 3000, 120, 0, tr("r/min"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //主轴运转转速, 范围1-3000，默认300
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        111, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle running speed"),//主轴运转转速
                                        300, 1, 3000, 300, 0, tr("r/min"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //主轴运转加速度, 范围1-100，默认50
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        112, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle running acceleration"),//主轴运转加速度
                                        50, 1, 100, 50, 0, tr("r/ss"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //主轴刹车加速度, 范围1-100，默认100
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        113, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle brake acceleration"),//主轴刹车加速度
                                        100, 1, 100, 100, 0, tr("r/ss"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //主轴缝纫最高转速, 范围1-3000，默认1200
        m_allParasList.append(makeAParaItem(0,
                                            PARA_TYPE_MACH,
                                            MC_SORT_SPEED,
                                            114, 0, 0, PARA_VALUE_TYPE_INT,
                                            tr("sewing maximum speed"),//主轴缝纫最高转速
                                            1200, 1, 3000, 1200, 0, tr("r/min"), tr(""),
                                            tr(""),
                                            0, 0, 0x0089, root));


    //主轴归零补偿角度, 范围：-1000-1000，默认200
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SETTING,
                                        146, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle zeroing compensation angle"),//主轴归零补偿角度
                                        200, -1000, 1000, 200, 2, cod->toUnicode("°"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //X间隙补偿, 范围-200-200，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SETTING,
                                        175, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("X gap compensation"),//X间隙补偿
                                        0, -200, 200, 0, 2, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, repair));

    //Y间隙补偿, 范围-200-200，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SETTING,
                                        177, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Y gap compensation"),//Y间隙补偿
                                        0, -200, 200, 0, 2, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, repair));

}

void ClothingMac::initWkParasList()
{
    QTextCodec *cod = QTextCodec::codecForLocale();

    //主轴缝纫工作转速, 范围1-3600，默认2000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SPEED,
                                        0, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Sewing main shaft working speed"),//主轴缝纫工作转速
                                        2000, 1, 3600, 2000, 0, tr("r/min"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    //主轴剪线转速, 范围1-500，默认120
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SPEED,
                                        1, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle cutting speed"),//主轴剪线转速
                                        120, 1, 500, 120, 0, tr("r/min"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //主轴回针转速, 范围1-1000，默认200
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SPEED,
                                        2, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle needle return speed"),//主轴回针转速
                                        200, 1, 1000, 200, 0, tr("r/min"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //主轴启动慢动转速, 范围1-1000，默认200
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SPEED,
                                        3, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle start slow speed"),//主轴启动慢动转速
                                        200, 1, 1000, 200, 0, tr("r/min"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //倒车等效主轴转速, 范围1-3000，默认1000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SPEED,
                                        4, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Reverse equivalent spindle speed"),//倒车等效主轴转速
                                        1000, 1, 3000, 1000, 0, tr("r/min"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //缝纫动框方式, 范围0-1，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        5, 4, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Sewing frame movement mode"),//缝纫动框方式
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr("XY continuous:0;XY intermittent:1"),//XY连续动框:0;XY间歇动框:1
                                        0, 0, 0x0001, operate));

    //缝纫动框起始角度, 范围0-36000，默认24000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_POSITION,
                                        6, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Sewing frame start angle"),//缝纫动框起始角度
                                        24000, 0, 36000, 24000, 2, cod->toUnicode("°"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //缝纫动框持续角度, 范围0-36000，默认24000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_POSITION,
                                        7, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Sewing frame steadiness angle"),//缝纫动框持续角度
                                        24000, 0, 36000, 24000, 2, cod->toUnicode("°"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //起针慢动针数, 范围0-10，默认3
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        8, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Slow stitch at beginning"),//起针慢动针数
                                        3, 0, 10, 3, 0, tr("Needle"), tr(""),//针
                                        tr(""),
                                        0, 0, 0x0001, operate));

    //起针动作松线允许, 范围0-1，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        9, 1, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Needle action, thread loosen allowed"),//起针动作松线允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr("Not allow:0;allowed:1"),//不允许:0;允许:1
                                        0, 0, 0x0001, root));

    //起针动作顶线允许, 范围0-1，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        9, 2, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Needle action,tight bobbin spring allowed"),//起针动作顶线允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr("Not allow:0;allowed:1"),//不允许:0;允许:1
                                        0, 0, 0x0001, root));

    //起针动作夹线允许, 范围0-1，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        9, 3, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Needle action, catch upper thread allowed"),//起针动作夹线允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr("Not allow:0;allowed:1"),//不允许:0;允许:1
                                        0, 0, 0x0001, root));

    //剪线允许, 范围0-3，默认1
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        10, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Cut thread allowed"),//剪线允许
                                        1, 0, 3, 1, 0, tr(""), tr(""),
                                        //不剪线:0;自动剪线:1;最后剪线:2;数据剪线:3
                                        tr("Do not trim:0;Automatic:1;Last trimming:2;Data trimming:3"),
                                        0, 0, 0x0001, operate));

    //剪线分线角度, 范围0-36000，默认20000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_POSITION,
                                        11, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Trimmer cutting angle"),//剪线分线角度
                                        20000, 0, 36000, 20000, 2, cod->toUnicode("°"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //剪线完成角度, 范围0-36000，默认6000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_POSITION,
                                        12, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Trimming completion angle"),//剪线完成角度
                                        6000, 0, 36000, 6000, 2, cod->toUnicode("°"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //剪线时动作松线允许, 范围0-1，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        13, 1, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Thread cut, upper thread loosen allowed"),//剪线时动作松线允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr("Not allow:0;allowed:1"),//不允许:0;允许:1
                                        0, 0, 0x0001, root));

    //剪线时动作拉线允许, 范围0-1，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        13, 2, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Thread cut, tensile thread allowed"),//剪线时动作拉线允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr("Not allow:0;allowed:1"),//不允许:0;允许:1
                                        0, 0, 0x0001, root));

    //剪线时动作夹线允许, 范围0-1，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        13, 3, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Thread cut, catch upper thread allowed"),//剪线时动作夹线允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr("Not allow:0;allowed:1"),//不允许:0;允许:1
                                        0, 0, 0x0001, root));

    //剪线时动作提升压脚允许, 范围0-1，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        13, 4, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Thread cut, presser foot lift allowed"),//剪线时动作提升压脚允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr("Not allow:0;allowed:1"),//不允许:0;允许:1
                                        0, 0, 0x0001, root));

    //断线检测针数, 范围0-10，默认3
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_DETECT,
                                        14, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Stitch detect if thread broken"),//断线检测针数
                                        3, 0, 10, 3, 0, tr("Needle"), tr(""),//针
                                        tr(""),
                                        0, 0, 0x0001, operate));

    //断线检测主轴角度, 范围0-36000，默认3000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SETTING,
                                        14, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Thread brake detection, main shaft angle"),//断线检测主轴角度
                                        3000, 0, 36000, 3000, 2, cod->toUnicode("°"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //换梭芯提醒功能, 范围0-3，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_DETECT,
                                        16, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Bobbin change reminder function"),//换梭芯提醒功能
                                        0, 0, 3, 0, 0, tr(""), tr(""),
                                        //不提醒: 0;按长度延时提醒:1;按片数提醒:2;按长度立刻提醒:3
                                        tr("Not enabled: 0;Delay reminder by length:1;Count by number of slices:2;Immediately reminder by length:3"),
                                        0, 0, 0x0001, operate));

    //底线长度, 范围0-最大，默认10000000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_DETECT,
                                        17, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Bobbin thread length"),//底线长度
                                        3, 0, S32_MAX, 3, 2, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    //每针底线修正量, 范围 最小-最大，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_DETECT,
                                        18, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Bobbin thread correction per stitch"),//每针底线修正量
                                        0, S32_MIN, S32_MAX, 0, 2, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    //换梭片数计数, 范围0-10，默认3
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_DETECT,
                                        19, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Bobbin change as per sewed pieces"),//换梭片数计数
                                        3, 0, 10, 3, 0, tr("times"), tr(""),//次
                                        tr(""),
                                        0, 0, 0x0001, operate));

    //加油方式选择, 范围0-3，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        20, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Oiling mode selection"),//加油方式选择
                                        0, 0, 3, 0, 0, tr(""), tr(""),
                                        //不加油: 0;按时间加油:1;按针数加油:2;持续加油:3
                                        tr("No oil:0;Oiling by time:1;Oiling by stitches:2;Oiling continously:3"),
                                        0, 0, 0x0001, operate));

    //加油针数间隔, 范围0-最大，默认10000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        21, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Oiling interval by needle stitch"),//加油针数间隔
                                        10000, 0, S32_MAX, 10000, 0, tr("Needle"), tr(""),//针
                                        tr(""),
                                        0, 0, 0x0001, operate));

    //加油时间间隔, 范围1-最大，默认1
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        22, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Oiling interval by working time"),//加油时间间隔
                                        1, 1, S32_MAX, 1, 0, tr("s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    //针加油持续时长, 范围1-最大，默认1
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        23, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Needle Oiling sustained time"),//针加油持续时长
                                        1, 1, S32_MAX, 1, 0, tr("s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    //完成后停车位置选择, 范围0-4，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        24, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Stop position selection after work complete"),//完成后停车位置选择
                                        0, 0, 4, 0, 0, tr(""), tr(""),
                                        //当前位置:0;起始点:1;定位点:2;上料点:3;偏移点:4
                                        tr("Current:0;Start:1;Anchor:2;Feeding:3;Offset:4"),
                                        0, 0, 0x0001, operate));

    //偏移点坐标有效标志, 范围0-3，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_POSITION,
                                        25, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Valid flag for offset point coordinates"),//偏移点坐标有效标志
                                        0, 0, 3, 0, 0, tr(""), tr(""),
                                        //无效:0;X有效:1;Y有效:2;XY同时有效:3
                                        tr("invalid:0;X is valid:1;Y is valid:2;XY is valid:3"),
                                        0, 0, 0x0001, operate));

    //偏移点坐标X, 范围：最小-最大，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_POSITION,
                                        26, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Offset point coordinate X"),//偏移点坐标X
                                        0, S32_MIN, S32_MAX, 0, 2, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    //偏移点坐标Y, 范围：最小-最大，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_POSITION,
                                        27, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Offset point coordinate Y"),//偏移点坐标Y
                                        0, S32_MIN, S32_MAX, 0, 2, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    //穿线点坐标有效标志, 范围0-3，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_POSITION,
                                        28, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Threading point coordinate valid symbol"),//穿线点坐标有效标志
                                        0, 0, 3, 0, 0, tr(""), tr(""),
                                        //无效:0;X有效:1;Y有效:2;XY同时有效:3
                                        tr("invalid:0;X is valid:1;Y is valid:2;XY is valid:3"),
                                        0, 0, 0x0001, operate));

    //穿线点坐标X, 范围：最小-最大，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_POSITION,
                                        29, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Threading point coordinates X"),//穿线点坐标X
                                        0, S32_MIN, S32_MAX, 0, 2, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    //穿线点坐标Y, 范围：最小-最大，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_POSITION,
                                        30, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Threading point coordinates Y"),//穿线点坐标Y
                                        0, S32_MIN, S32_MAX, 0, 2, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    //产量预设, 范围0-S32_MAX，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SETTING,
                                        33, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Production preset"),//产量预设
                                        0, 0, S32_MAX, 0, 0, tr(""), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    //气框关闭后延时, 范围0-2000，默认500
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        35, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Delay after pneumatic frame off"),//气框关闭后延时
                                        500, 0, 2000, 500, 0, tr(""), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    //缝纫加速度, 范围1-100，默认5
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SPEED,
                                        36, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Sewing acceleration"),//缝纫加速度
                                        5, 1, 100, 5, 0, tr("r/ss"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    //剪线动框位移, 范围1-5000，默认500
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        37, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Trimming frame displacement"),//剪线动框位移
                                        500, 1, 5000, 500, 2, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //自动回穿线点允许, 范围0-1，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        38, 3, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Automatic move to threading point allowed"),//自动回穿线点允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr("Not allow:0;allowed:1"),//不允许:0;允许:1
                                        0, 0, 0x0001, operate));

    //大压脚动作允许, 范围0-1，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        38, 7, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Large presser foot action allowed"),//大压脚动作允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr("Not allow:0;allowed:1"),//不允许:0;允许:1
                                        0, 0, 0x0001, root));

    //缝纫间越框机头升降, 范围0-1，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        46, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Sewing move head up down"),//缝纫间越框机头升降
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr("Not allow:0;allowed:1"),//不允许:0;允许:1
                                        0, 0, 0x0001, root));

    //移框松线允许, 范围0-1，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        48, 1, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Moving basket Loose line"),//移框松线允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr("Not allow:0;allowed:1"),//不允许:0;允许:1
                                        0, 0, 0x0001, root));

    //移框夹线允许, 范围0-1，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        48, 2, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Moving basket Clamp line"),//移框夹线允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr("Not allow:0;allowed:1"),//不允许:0;允许:1
                                        0, 0, 0x0001, root));

    //软件限位XY移动允许, 范围0-1，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_DETECT,
                                        49, 1, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Software limit XY move allowed"),//软件限位XY移动允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr("Not allow:0;allowed:1"),//不允许:0;允许:1
                                        0, 0, 0x0001, root));

    //面线勾线针数, 范围0-5，默认1
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        52, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Number of Needle hooks"),//面线勾线针数
                                        1, 0, 5, 1, 0, tr(""), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    //剪线动框方向, 范围0-4，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        57, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Trimming frame direction"),//剪线动框方向
                                        0, 0, 4, 0, 0, tr(""), tr(""),
                                        tr("No:0;left:1;Forward:2;Right:3;Backward:4"),//不移动:0;向左:1;向前:2;向右:3;向后:4
                                        0, 0, 0x0001, root));

    //主轴拐角转速, 范围1-3000，默认1000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SPEED,
                                        59, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle corner speed"),//主轴拐角转速
                                        1000, 1, 3000, 1000, 0, tr("r/min"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //降速最小偏差角度, 范围0-180，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SPEED,
                                        60, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Minimum speed deviation angle"),//降速最小偏差角度
                                        0, 0, 180, 0, 0, cod->toUnicode("°"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //提前降速针步, 范围0-20，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        61, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Early speed reduction"),//提前降速针步
                                        0, 0, 20, 0, 0, tr(""), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //延迟提速针步, 范围0-20，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        62, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Delayed speed step"),//延迟提速针步
                                        0, 0, 20, 0, 0, tr(""), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));

    //安全输入光幕允许, 范围0-1，默认1
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_DETECT,
                                        101, 1, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Secure input light curtain allows"),//安全输入光幕允许
                                        1, 0, 1, 1, 0, tr(""), tr(""),
                                        tr("Not allow:0;allowed:1"),//不允许:0;允许:1
                                        0, 0, 0x0001, root));

    //安全输入气压允许, 范围0-1，默认1
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_DETECT,
                                        101, 2, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Safety input pressure allowed"),//安全输入气压允许
                                        1, 0, 1, 1, 0, tr(""), tr(""),
                                        tr("Not allow:0;allowed:1"),//不允许:0;允许:1
                                        0, 0, 0x0001, root));

    //自动气框关闭允许, 范围0-1，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        102, 1, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Pneumatic frame off"),//自动气框关闭允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr("Not allow:0;allowed:1"),//不允许:0;允许:1
                                        0, 0, 0x0001, operate));

    //自动气框打开允许, 范围0-1，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        102, 2, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Penumatic frame on"),//自动气框打开允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr("Not allow:0;allowed:1"),//不允许:0;允许:1
                                        0, 0, 0x0001, operate));

    //自动气框闭合延时, 范围0-5000，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        103, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Penumatic frame on"),//自动气框闭合延时
                                        0, 0, 5000, 0, 0, tr("ms"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    //循环工作允许, 范围0-1，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SETTING,
                                        105, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Loop work allowed"),//循环工作允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr("Not allow:0;allowed:1"),//不允许:0;允许:1
                                        0, 0, 0x0001, operate));

    //梭加油持续时长, 范围0-最大，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        110, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Shuttle Oiling sustained time"),//梭加油持续时长
                                        0, 0, S32_MAX, 0, 0, tr("s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    //缝纫运行速度1, 范围1-5000，默认500
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SPEED,
                                        170, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Sewing operation speed 1"),//缝纫运行速度1
                                        500, 1, 5000, 500, 0, tr("r/min"), tr(""),//次
                                        tr(""),
                                        0, 0, 0x0001, root));

    //缝纫运行速度2, 范围1-5000，默认1000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SPEED,
                                        171, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Sewing operation speed 2"),//缝纫运行速度2
                                        1000, 1, 5000, 1000, 0, tr("r/min"), tr(""),//次
                                        tr(""),
                                        0, 0, 0x0001, root));

    //缝纫运行速度3, 范围1-5000，默认1000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SPEED,
                                        172, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Sewing operation speed 3"),//缝纫运行速度3
                                        1500, 1, 5000, 1500, 0, tr("r/min"), tr(""),//次
                                        tr(""),
                                        0, 0, 0x0001, root));

    //更换缝纫针计数值, 范围0-S32_MAX，默认500000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_DETECT,
                                        190, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Change the sewing needle count value"),//更换缝纫针计数值
                                        500000, 0, S32_MAX, 500000, 0, tr("times"), tr(""),//次
                                        tr(""),
                                        0, 0, 0x0001, root));
}

void ClothingMac::initOutCtrlList()
{
    m_allOutCtrlList.clear();

    QString enableStr = tr("Enable");   //使能
    QString disableStr = tr("Disable"); //失能
    QString jogPStr = tr("JogP"); //正转
    QString jogNStr = tr("JogN"); //反转
    QString zeroStr = tr("Zero"); //归零
    QString openStr = tr("Open"); //打开
    QString closeStr = tr("Close");//关闭
    QString upStr = tr("Up"); //上升
    QString downStr = tr("Down");//下降
    QString extStr = tr("Extend"); //伸出
    QString backStr = tr("Back");//收回
    QString comStr = tr("Combine"); //结合
    QString sepStr = tr("Separate");//分离
    //QString testStr = tr("Test");//测试

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x0001,tr("X to move motor"),MT_LX,// X向移动电机
                                             enableStr,true,OUTCONTROL_ENABLE,-1,-1,
                                             disableStr,true,OUTCONTROL_DISABLE,-1,-1,
                                             jogPStr,true,-1,OUTCONTROL_JOGP,OUTCONTROL_STOP,
                                             jogNStr,true,-1,OUTCONTROL_JOGN,OUTCONTROL_STOP,
                                             zeroStr,true,OUTCONTROL_ZERO,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x0002,tr("Y to move motor"),MT_LY,// Y向移动电机
                                             enableStr,true,OUTCONTROL_ENABLE,-1,-1,
                                             disableStr,true,OUTCONTROL_DISABLE,-1,-1,
                                             jogPStr,true,-1,OUTCONTROL_JOGP,OUTCONTROL_STOP,
                                             jogNStr,true,-1,OUTCONTROL_JOGN,OUTCONTROL_STOP,
                                             zeroStr,true,OUTCONTROL_ZERO,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x0003,tr("Spindle motor"),MT_LM,// 主轴电机
                                             enableStr,true,OUTCONTROL_ENABLE,-1,-1,
                                             disableStr,true,OUTCONTROL_DISABLE,-1,-1,
                                             jogPStr,true,-1,OUTCONTROL_JOGP,OUTCONTROL_STOP,
                                             jogNStr,true,-1,OUTCONTROL_JOGN,OUTCONTROL_STOP,
                                             zeroStr,true,OUTCONTROL_ZERO,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x0004,tr("Needle motor"),MT_LN,// 针电机
                                             enableStr,true,OUTCONTROL_ENABLE,-1,-1,
                                             disableStr,true,OUTCONTROL_DISABLE,-1,-1,
                                             jogPStr,true,-1,OUTCONTROL_JOGP,OUTCONTROL_STOP,
                                             jogNStr,true,-1,OUTCONTROL_JOGN,OUTCONTROL_STOP,
                                             zeroStr,true,OUTCONTROL_ZERO,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x0005,tr("Shuttle motor"),MT_LH,// 梭电机
                                             enableStr,true,OUTCONTROL_ENABLE,-1,-1,
                                             disableStr,true,OUTCONTROL_DISABLE,-1,-1,
                                             jogPStr,true,-1,OUTCONTROL_JOGP,OUTCONTROL_STOP,
                                             jogNStr,true,-1,OUTCONTROL_JOGN,OUTCONTROL_STOP,
                                             zeroStr,true,OUTCONTROL_ZERO,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x0006,tr("Lifting motor"),MT_LU,// 升降电机
                                             enableStr,true,OUTCONTROL_ENABLE,-1,-1,
                                             disableStr,true,OUTCONTROL_DISABLE,-1,-1,
                                             jogPStr,true,-1,OUTCONTROL_JOGP,OUTCONTROL_STOP,
                                             jogNStr,true,-1,OUTCONTROL_JOGN,OUTCONTROL_STOP,
                                             zeroStr,true,OUTCONTROL_ZERO,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x0007,tr("Frame"),OT_FRAME,// 气框
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_OPEN,-1,-1,
                                             closeStr,true,OUTCONTROL_CLOSE,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x0008,tr("Big foot"),OT_BIT_FOOT,// 大压脚
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             upStr,true,OUTCONTROL_OPEN,-1,-1,
                                             downStr,true,OUTCONTROL_CLOSE,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x0009,tr("Middle foot"),OT_MID_FOOT,// 中压脚
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             upStr,true,OUTCONTROL_OPEN,-1,-1,
                                             downStr,true,OUTCONTROL_CLOSE,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x000A,tr("Buckle the bottom line"),OT_PUSH_BTRD,// 扣底线
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_OPEN,-1,-1,
                                             closeStr,true,OUTCONTROL_CLOSE,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x000B,tr("Top and bottom lines"),OT_STAND_BTRD,// 顶底线
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_OPEN,-1,-1,
                                             closeStr,true,OUTCONTROL_CLOSE,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x000C,tr("Lower scissors to cut thread"),OT_DCUT_THREAD,// 下剪刀剪线
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_OPEN,-1,-1,
                                             closeStr,true,OUTCONTROL_CLOSE,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x000D,tr("Sandwich line"),OT_CLIP_UTRD,// 夹面线
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_OPEN,-1,-1,
                                             closeStr,true,OUTCONTROL_CLOSE,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x000E,tr("Elastic thread"),OT_LOOSE_THREAD,// 松紧线
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_OPEN,-1,-1,
                                             closeStr,true,OUTCONTROL_CLOSE,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x000F,tr("Elastic thread 2"),OT_LOOSE_UTRD2,// 第二松紧线
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_OPEN,-1,-1,
                                             closeStr,true,OUTCONTROL_CLOSE,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x0010,tr("Laser control"),OT_LASER_CTRL,// 激光控制
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_OPEN,-1,-1,
                                             closeStr,true,OUTCONTROL_CLOSE,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x0011,tr("Laser blow"),OT_LASER_BLOW,// 激光控制
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_OPEN,-1,-1,
                                             closeStr,true,OUTCONTROL_CLOSE,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x0012,tr("Oil"),OT_OIL,// 加油
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_OPEN,-1,-1,
                                             closeStr,true,OUTCONTROL_CLOSE,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x0013,tr("Headlamp"),OT_LIGHT,// 照明灯
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_OPEN,-1,-1,
                                             closeStr,true,OUTCONTROL_CLOSE,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x0014,tr("Sewing Blow"),OT_SEW_BLOW,// 缝纫吹气
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_OPEN,-1,-1,
                                             closeStr,true,OUTCONTROL_CLOSE,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x0015,tr("Hookline ext"),OT_CLIP_EXTEND,// 勾线伸出
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             extStr,true,OUTCONTROL_OPEN,-1,-1,
                                             backStr,true,OUTCONTROL_CLOSE,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x0016,tr("Hookline open and close"),OT_CLIP_EXTEND,// 勾线开合
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_OPEN,-1,-1,
                                             closeStr,true,OUTCONTROL_CLOSE,-1,-1));

//    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x0016,tr("Scan code test"),OT_CLIP_EXTEND,// 扫码测试
//                                             "",false,-1,-1,-1,
//                                             "",false,-1,-1,-1,
//                                             "",false,-1,-1,-1,
//                                             "",false,-1,-1,-1,
//                                             testStr,true,OUTCONTROL_CLOSE,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x0016,tr("Sewing machine head lifting"),OT_SEW_LIFT,// 缝纫机头升降
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             upStr,true,OUTCONTROL_OPEN,-1,-1,
                                             downStr,true,OUTCONTROL_CLOSE,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x0017,tr("Spindle clutch"),OT_HEAD_L_CLUTH,// 主轴离合
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             comStr,true,OUTCONTROL_OPEN,-1,-1,
                                             sepStr,true,OUTCONTROL_CLOSE,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,0x0018,tr("Pen"),OT_PEN_DOWN,// 画笔
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             upStr,true,OUTCONTROL_OPEN,-1,-1,
                                             downStr,true,OUTCONTROL_CLOSE,-1,-1));
}

void ClothingMac::initShortCutList()
{
    m_allShortCutList.clear();
    int index = 1;
    m_allShortCutList.append(makeAShortCutItem(0, index++, tr("All to zero"),"buttonAllToZero",FUN_ALLTOZERO));//全部归零
    m_allShortCutList.append(makeAShortCutItem(0, index++, tr("Needle shuttle reset"),"buttonNeedleShuttleReset",FUN_NEEDLESHUTTLERESET));//针梭校对
    m_allShortCutList.append(makeAShortCutItem(0, index++, tr("Back thread"),"buttonBackThread",FUN_BACKTHREADPOINT));//回穿线点
    m_allShortCutList.append(makeAShortCutItem(0, index++, tr("Back offset"),"buttonBackOffsetPoint",FUN_BACKOFFSETPOINT));//回偏移点
    m_allShortCutList.append(makeAShortCutItem(0, index++, tr("Back shuttle"),"buttonBackShuttle",FUN_BACKSHUTTLE));//回换梭位
    m_allShortCutList.append(makeAShortCutItem(0, index++, tr("Back work"),"buttonBackWorkPoint",FUN_BACKWORKPOINT));//回工作点
    m_allShortCutList.append(makeAShortCutItem(0, index++, tr("Set anchor"),"buttonSetAnchorPoint",FUN_SETANCHORPOINT));//定定位点
    m_allShortCutList.append(makeAShortCutItem(0, index++, tr("Back anchor"),"buttonBackAnchorPoint",FUN_BACKANCHORPOINT));//回定位点
    m_allShortCutList.append(makeAShortCutItem(0, index++, tr("Back start"),"buttonSetEmbPoint",FUN_SETSTARTPOINT));//定起始点
    m_allShortCutList.append(makeAShortCutItem(0, index++, tr("Back start"),"buttonBackEmbPoint",FUN_BACKSTARTPOINT));//回起始点
    m_allShortCutList.append(makeAShortCutItem(0, index++, tr("Forwrak or back"),"buttonForwardOrBack",FUN_FORWARDORBACK));//前进回退
    m_allShortCutList.append(makeAShortCutItem(0, index++, tr("Bottom count reset"),"buttonShutCount",FUN_COUNTRESET));//底线计数清零
    m_allShortCutList.append(makeAShortCutItem(0, index++, tr("HeadLifting"),"buttonHeadLifting",FUN_HEAD_LIFTING));
    m_allShortCutList.append(makeAShortCutItem(0, index++, tr("ThreadCut"),"buttonMunualThreadCutting",FUN_MANUAL_THREAD_CUTTING));
    m_allShortCutList.append(makeAShortCutItem(0, index++, tr("ProcessReset"),"buttonProcessReset",FUN_PROCESSRESET));
    m_allShortCutList.append(makeAShortCutItem(0, index++, tr("Simulated"),"buttonSimulatedStatus",FUN_SIMULATED_STATUS));
}

void ClothingMac::initAssistList()
{
    m_allAssistList.clear();

    m_allAssistList.append(makeAAssistItem(0,0x0001,tr("Signal"),"buttonSensor",ASSIST_SENSOR));//传感器信号
    m_allAssistList.append(makeAAssistItem(0,0x0002,tr("Action"),"buttonControlAction",ASSIST_CONTROLACTION));//控制动作
    m_allAssistList.append(makeAAssistItem(0,0x0003,tr("HMIUpgrade"),"buttonHMIUpgrade",ASSIST_HMIUPGRADE));//界面升级
    m_allAssistList.append(makeAAssistItem(0,0x0004,tr("MCUpgrade"),"buttonMCUpgrade",ASSIST_MCUPGRADE));//主控升级
    m_allAssistList.append(makeAAssistItem(0,0x0006,tr("ParaImport"),"buttonParaImport",ASSIST_PARAIMPORT));//参数导入
    m_allAssistList.append(makeAAssistItem(0,0x0007,tr("ParaExport"),"buttonParaExport",ASSIST_PARAEXPORT));//参数导出
    m_allAssistList.append(makeAAssistItem(0,0x0008,tr("SoftwareSet"),"buttonSoftwareSet",ASSIST_SOFTWARESET));//软件设置
    m_allAssistList.append(makeAAssistItem(0,0x0009,tr("Authorization"),"buttonSoftwareAuthor",ASSIST_AUTHORIZATION));//软件授权
    m_allAssistList.append(makeAAssistItem(0,0x000A,tr("Network"),"buttonNetworkManage",ASSIST_NETWORK));//网络管理
    m_allAssistList.append(makeAAssistItem(0,0x000C,tr("Time"),"buttonTimeSet",ASSIST_TIMESET));//时间设置
    m_allAssistList.append(makeAAssistItem(0,0x000F,tr("Version"),"buttonVersionInfo",ASSIST_MCVERSION));//版本信息
    m_allAssistList.append(makeAAssistItem(0,0x0014,tr("Root"),"buttonRoot",ASSIST_ROOT));//超级用户
}

void ClothingMac::initPatternSetList()
{
    m_allPatternSetList.clear();

    m_allPatternSetList.append(makeAPatternSetItem(0,0x0002,tr("Para"),"buttonPatternPara",PATTERNSET_PATTERNPARA));//花样参数
    m_allPatternSetList.append(makeAPatternSetItem(0,0x0001,tr("Select"),"buttonPatternSelect",PATTERNSET_PATTERNSELECT));//花样选择
    m_allPatternSetList.append(makeAPatternSetItem(0,0x0004,tr("Import"),"buttonPatternImport",PATTERNSET_PATTERNIMPORT));//花样导入
    m_allPatternSetList.append(makeAPatternSetItem(0,0x0005,tr("Export"),"buttonPatternExport",PATTERNSET_PATTERNEXPORT));//花样导出
    m_allPatternSetList.append(makeAPatternSetItem(0,0x0006,tr("Delete"),"buttonPatternDelete",PATTERNSET_PATTERNDELETE));//花样删除
}

void ClothingMac::initParaSetList()
{
    m_allParaSetList.clear();

    m_allParaSetList.append(makeAParaSetItem(0,0x0001,tr("OperatPara"),"buttonPositionParas",PARASET_SETTING));//设置参数  //操作参数
    m_allParaSetList.append(makeAParaSetItem(0,0x0002,tr("ActionSet"),"buttonActionParas",PARASET_ACTION));//动作参数   //动作设定
    m_allParaSetList.append(makeAParaSetItem(0,0x0003,tr("SpeedPara"),"buttonSpeedParas",PARASET_SPEED));//速度参数  //速度控制参数
    m_allParaSetList.append(makeAParaSetItem(0,0x0004,tr("LimitPara"),"buttonDetectParas",PARASET_POSITION));// 位置参数  //限位参数
    m_allParaSetList.append(makeAParaSetItem(0,0x0005,tr("MCPara"),"buttonSettingParas",PARASET_DETECT));//设置参数    //机器参数
}

void ClothingMac::initSensorList()
{
    QList <SensorItem> sensorList;

    sensorList.append(makeASensorItem(0x0000, 0, tr("Start button 1")));//启动按钮1
    sensorList.append(makeASensorItem(0x0001, 0, tr("Pause button 1")));//暂停按钮1
    sensorList.append(makeASensorItem(0x0007, 0, tr("Air pressure detection 1")));//气压检测1
    sensorList.append(makeASensorItem(0x0008, 0, tr("Security input 1")));//安全输入1
    sensorList.append(makeASensorItem(0x0020, 0, tr("X zero position")));//X零位
    sensorList.append(makeASensorItem(0x0021, 1, tr("Y deceleration")));//Y降速
    sensorList.append(makeASensorItem(0x0023, 0, tr("X positive limit")));//X正限位
    sensorList.append(makeASensorItem(0x0023, 1, tr("Y positive limit")));//Y正限位

    sensorList.append(makeASensorItem(0x0040, 0, tr("Sewing machine head 1 lifting upper limit")));//缝纫机头1升降上限位
    sensorList.append(makeASensorItem(0x0042, 0, tr("Lower lifting limit of sewing machine head 1")));//缝纫机头1升降下限位
    sensorList.append(makeASensorItem(0x0080, 0, tr("Sewing spindle 1 needle - parking space")));//缝纫主轴1针-停车位
    sensorList.append(makeASensorItem(0x0088, 0, tr("Sewing shuttle 1- parking space")));//缝纫旋梭1-停车位
    sensorList.append(makeASensorItem(0x0170, 0, tr("Sewing machine head 1 - surface thread breakage inspection")));//缝纫机头1-面线断检

    //将机型所需的传感器列表替换到传感器整体列表中
    for(int i = 0; i < sensorList.size(); i++)
    {
        int byteaddr = sensorList[i].m_byte_offset;
        int bitaddr = sensorList[i].m_bit_offset;
        QString str = sensorList[i].m_name;
        int type = sensorList[i].m_type;

        int idx = byteaddr*8+bitaddr;
        if(idx < m_allSensorList.size())
        {
            m_allSensorList[idx].m_name = str;
            m_allSensorList[idx].m_type = type;
        }
    }
}

void ClothingMac::initErrorCodeAndStateList()
{
    //暂时无专用的错误代码，都为通用的
    m_allErrorCodeAndStateList.clear();
}
